package com.Arrays_;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author 小闽
 * @Date 2024/10/8 11:46
 * @PackageName: com.Arrays_
 * @ClassName: ArraysMethod01
 * @Description: 数组类的常用方法1
 * @Version 1.0
 */
public class ArraysMethod01 {
    public static void main(String[] args) {
        Integer[] integers = {1, 20, 90};
        // 遍历数组
        for (int i = 0; i < integers.length; i++) {
            System.out.println(integers[i]);
        }
        // 直接使用Arrays.toString方法，显示数组
        // 源码分析
        // 接受一个数组参数
//        public static String toString(Object[] a) {
        // 判断当前参数是否为null,如果是则返回一个字符串的null
//            if (a == null)
//                return "null";
//         将数组长度-1的下标赋值给iMax
//            int iMax = a.length - 1;
        // 如果iMax的值为-1，则返回一个"[]"
//            if (iMax == -1)
//                return "[]";
//          创建一个StringBuilder对象
//            StringBuilder b = new StringBuilder();
        // 把左中括号添加到StringBuffer对象中
//            b.append('[');
        // 循环数组中的元素
//            for (int i = 0; ; i++) {
        // 把数组中的每一个元素添加到StringBuffer对象中，并在每个元素的后面添加逗号
//                b.append(String.valueOf(a[i]));
        // 如果当 i = iMax,则在StringBuffer的最后添加右中括号
//                if (i == iMax)
//                    return b.append(']').toString();
//                b.append(", ");
//            }
//        }
        String arr = Arrays.toString(integers);
        System.out.println(arr);

        Integer arr1[] = {1, -1, 7, 0, 89};
        // 进行排序
        // 1. 可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序
        // 2. 因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
        // 3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //Arrays.sort(arr1); // 默认排序方法
        // 定制排序
        // 4. 调用定制排序时，传入两个参数（1）排序的数组arr
        //    (2) 实现了Comparator接口的匿名内部类，要求实现 compare方法
        // 5. 这里充分体现了接口编程的方式，看源码
        // 6. 源码分析
        //    (1) 先调用 Arrays.sort(arr1, new Comparator() {}) 方法
        //    (2) 然后进入到  TimSort.sort(a, 0, a.length, c, null, 0, 0); 方法中
        //    (3) 然后进入到  binarySort(a, lo, hi, lo + initRunLen, c); 方法中
        //    (4) 然后进入到
        /**
         * while (left < right) {
         *                 int mid = (left + right) >>> 1;
         *                 if (c.compare(pivot, a[mid]) < 0)
         *                     right = mid;
         *                 else
         *                     left = mid + 1;
         *             }
         *             assert left == right;
         */
        // 去调用 c.compare() 方法通过动态绑定和接口编程以及匿名内部类来实现
        //  (5) 调用 c.compare() 方法
        /**
         * new Comparator() {
         *             @Override
         *             public int compare(Object o1, Object o2) {
         *                 Integer i1 = (Integer) o1;
         *                 Integer i2 = (Integer) o2;
         *                 return i2 - i1;
         *             }
         */
        // 根据 匿名内部类中 compare() 方法去实现动态的数组排序方式
        // public int compare(Object o1, Object o2) {} 方法中返回的值是 >0 还是 <0 对于整个的排序结果有一定的影响
        Arrays.sort(arr1, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }

        });
        System.out.println("=====排序后=====");
        System.out.println(Arrays.toString(arr1));

    }
}
